Numeri Negativi e Reali in Binario

📚 1. Introduzione

Finora abbiamo visto come rappresentare numeri interi positivi in binario. Ma come facciamo a rappresentare numeri negativi e numeri con la virgola? Questo è fondamentale per permettere ai computer di eseguire calcoli realistici.

💡 Problemi da risolvere

Numeri negativi: Come distinguere -5 da +5 in binario?
Numeri decimali: Come rappresentare 3.14, 0.5, -2.75?
Range e precisione: Come bilanciare numeri molto grandi e molto piccoli?

📊 Metodi di rappresentazione

Metodo	Cosa rappresenta	Complessità	Uso
Segno e Modulo	Numeri interi con segno	⭐ Facile	Didattico (poco usato)
Complemento a 2	Numeri interi con segno	⭐⭐ Media	Standard per interi
Virgola Fissa	Numeri decimali con precisione fissa	⭐⭐ Media	DSP, finanza
Virgola Mobile (IEEE 754)	Numeri decimali con range ampio	⭐⭐⭐ Avanzata	Standard universale

➖ 2. Rappresentazione dei Numeri Negativi

📋 Metodo 1: Segno e Modulo (Sign-Magnitude)

Il metodo più intuitivo: usiamo 1 bit per il segno (0=positivo, 1=negativo) e i restanti bit per il valore assoluto.

Esempio con 8 bit:

S 7 6 5 4 3 2 1

S = bit di segno (0=+, 1=-) | 7-1 = valore assoluto

Esempi con 8 bit:
+5  = 0 0000101
-5  = 1 0000101
+42 = 0 0101010
-42 = 1 0101010
+0  = 0 0000000
-0  = 1 0000000  ← Problema: due rappresentazioni per zero!

⚠️ Problemi del segno-modulo

Esistono due zeri (+0 e -0)
Hardware complesso per addizioni/sottrazioni
Range asimmetrico: con 8 bit vai da -127 a +127

📋 Metodo 2: Complemento a 1 (One's Complement)

Per ottenere il negativo di un numero, si invertono tutti i bit.

Esempi con 8 bit:
+5  = 00000101
-5  = 11111010  (tutti i bit invertiti)

+42 = 00101010
-42 = 11010101

+0  = 00000000
-0  = 11111111  ← Ancora due zeri!

⚠️ Problema del complemento a 1

Persiste il problema dei due zeri e richiede correzioni nell'hardware.

📋 Metodo 3: Complemento a 2 (Two's Complement) ✅

Questo è il metodo standard usato in tutti i computer moderni! Per ottenere il negativo: inverti tutti i bit e aggiungi 1.

✅ Vantaggi del complemento a 2

Un solo zero (00000000)
Addizione e sottrazione usano lo stesso circuito
Range: da -2ⁿ⁻¹ a +2ⁿ⁻¹-1
Estensione del segno semplice

Calcolare -42 in complemento a 2 (8 bit)

Passo 1: Scrivi +42 in binario
   00101010

Passo 2: Inverti tutti i bit (complemento a 1)
   11010101

Passo 3: Aggiungi 1
   11010101
 +        1
 ----------
   11010110  ← Questo è -42 in complemento a 2!

📊 Range con complemento a 2

Bit	Range	Più piccolo (binario)	Più grande (binario)
4 bit	-8 a +7	1000 = -8	0111 = +7
8 bit	-128 a +127	10000000 = -128	01111111 = +127
16 bit	-32768 a +32767	1000000000000000	0111111111111111
32 bit	-2³¹ a +2³¹-1	≈ -2.1 miliardi	≈ +2.1 miliardi

💡 Come riconoscere il segno

In complemento a 2, guarda il bit più significativo (MSB):

MSB = 0 → Numero positivo o zero
MSB = 1 → Numero negativo

📍 3. Virgola Fissa (Fixed-Point)

Nella rappresentazione a virgola fissa, si stabilisce una volta per tutte quanti bit dedicare alla parte intera e quanti alla parte frazionaria.

📊 Formato Qm.n

La notazione Qm.n indica:

m = bit per la parte intera (incluso segno)
n = bit per la parte frazionaria

Esempio: Q4.4 (8 bit totali)

S 2 1 0 . -1 -2 -3 -4

Parte intera (4 bit) | Virgola fissa | Parte frazionaria (4 bit)

Esempio: Rappresentare 5.75 in Q4.4

Passo 1: Converti la parte intera
   5₁₀ = 0101₂

Passo 2: Converti la parte frazionaria
   0.75 = 0.5 + 0.25
        = 1/2 + 1/4
        = 2⁻¹ + 2⁻²
        = 0.1100₂

Passo 3: Combina
   5.75 = 0101.1100

In Q4.4: 01011100

🎯 Conversione parte frazionaria

Come convertire 0.625 in binario

Moltiplica per 2 ripetutamente:

0.625 × 2 = 1.25  → Bit: 1, resto 0.25
0.25  × 2 = 0.5   → Bit: 0, resto 0.5
0.5   × 2 = 1.0   → Bit: 1, resto 0

Risultato: 0.625₁₀ = 0.101₂

⚠️ Limiti della virgola fissa

Range limitato: Q4.4 va da -8.0 a +7.9375
Precisione fissa: Con 4 bit frazionari, step minimo = 2⁻⁴ = 0.0625
Sprechi: Se rappresenti 0.001, sprechi i bit della parte intera

📊 Esempi di formati a virgola fissa

Formato	Bit totali	Parte intera	Parte frazionaria	Range	Precisione
Q4.4	8	4	4	-8 a +7.9375	0.0625
Q8.8	16	8	8	-128 a +127.996	0.00390625
Q16.16	32	16	16	-32768 a +32767.999	0.0000152587

🌊 4. Virgola Mobile (Floating-Point)

La rappresentazione a virgola mobile (floating-point) risolve i limiti della virgola fissa permettendo di rappresentare numeri con range enorme e precisione variabile.

💡 Notazione Scientifica

La virgola mobile si basa sulla notazione scientifica:

💡 Formato generale

Numero = (-1)ˢ × M × B^E

Dove:
• s = bit di segno (0 o 1)
• M = mantissa (parte significativa)
• B = base (2 per binario)
• E = esponente

Esempi in decimale:

123.45 = 1.2345 × 10²
0.00056 = 5.6 × 10⁻⁴
-6789000 = -6.789 × 10⁶

📊 Vantaggi della virgola mobile

✅ Perché usare la virgola mobile?

Range enorme: Da ≈10⁻³⁸ a ≈10³⁸ con 32 bit
Precisione relativa: Più cifre significative per numeri piccoli e grandi
Standard universale: IEEE 754 usato in tutti i processori
Hardware efficiente: FPU (Floating-Point Unit) dedicate

🔢 5. IEEE 754 Single Precision (32 bit)

Lo standard IEEE 754 single precision (chiamato anche float in molti linguaggi) usa 32 bit divisi in tre parti.

Struttura di un float (32 bit):

S E E E E E E E E M M M ... M M M

■ Segno (1 bit) | ■ Esponente (8 bit) | ■ Mantissa (23 bit)

📋 Componenti del formato

🔴 Bit di Segno (1 bit)

0 = numero positivo
1 = numero negativo

🟡 Esponente (8 bit) - Bias 127

L'esponente è rappresentato con bias +127:

Esponente memorizzato = Esponente reale + 127
Range: da -126 a +127
00000000 e 11111111 sono riservati per casi speciali

Esempi:
Esponente reale = 0   → Memorizzato: 127   (01111111)
Esponente reale = 5   → Memorizzato: 132   (10000100)
Esponente reale = -3  → Memorizzato: 124   (01111100)

🔵 Mantissa (23 bit) - Normalizzata

La mantissa rappresenta la parte frazionaria con un 1 implicito:

Formato: 1.xxxxxxxxxxxxxxxxx (1 + 23 bit frazionari)
Il "1." è implicito e non viene memorizzato (bit nascosto)
Si guadagna 1 bit di precisione!

🎯 Formula completa

✅ Formula IEEE 754 Single Precision

Valore = (-1)ˢ × (1 + mantissa) × 2^(esponente - 127)

Dove:
• s = bit di segno
• mantissa = 23 bit interpretati come frazione
• esponente = 8 bit interpretati come intero senza segno

Esempio completo: Rappresentare -12.375 in IEEE 754 single precision

Passo 1: Determina il segno
   -12.375 è negativo → s = 1

Passo 2: Converti il valore assoluto in binario
   12₁₀ = 1100₂
   0.375 = 0.25 + 0.125 = 2⁻² + 2⁻³ = 0.011₂
   12.375 = 1100.011₂

Passo 3: Normalizza (sposta la virgola dopo il primo 1)
   1100.011 = 1.100011 × 2³
   
   Esponente reale: 3

Passo 4: Calcola l'esponente con bias
   Esponente memorizzato = 3 + 127 = 130
   130₁₀ = 10000010₂

Passo 5: Estrai la mantissa (senza il "1." iniziale)
   1.100011 → mantissa = 10001100000000000000000 (23 bit)

Passo 6: Combina tutto
   S: 1
   E: 10000010
   M: 10001100000000000000000
   
   Risultato: 1 10000010 10001100000000000000000

📊 Valori speciali

Valore	Esponente	Mantissa	Significato
Zero	00000000	tutti 0	±0 (dipende dal segno)
Denormalizzati	00000000	non tutti 0	Numeri molto piccoli
Infinito	11111111	tutti 0	±∞ (overflow)
NaN	11111111	non tutti 0	Not a Number (0/0, √-1)

📏 Precisione e Range

💡 Caratteristiche del float (32 bit)

Precisione: ≈ 7 cifre decimali significative
Range positivo: da ≈1.4 × 10⁻⁴⁵ a ≈3.4 × 10³⁸
Epsilon macchina: ≈1.19 × 10⁻⁷ (più piccola differenza rappresentabile)

🔢🔢 6. IEEE 754 Double Precision (64 bit)

Il formato double precision (chiamato double) usa 64 bit per una precisione e range maggiori.

Struttura di un double (64 bit):

S E ×11 M ×52

■ Segno (1 bit) | ■ Esponente (11 bit) | ■ Mantissa (52 bit)

🔵 Differenze rispetto al float

Componente	Float (32 bit)	Double (64 bit)
Bit esponente	8 bit	11 bit
Bias esponente	127	1023
Bit mantissa	23 bit	52 bit
Precisione decimale	≈ 7 cifre	≈ 15-16 cifre
Range	≈±10³⁸	≈±10³⁰⁸

🎯 Formula Double Precision

✅ Formula IEEE 754 Double Precision

Valore = (-1)ˢ × (1 + mantissa) × 2^(esponente - 1023)

Dove:
• s = bit di segno
• mantissa = 52 bit interpretati come frazione
• esponente = 11 bit interpretati come intero senza segno
• bias = 1023 (invece di 127)

🎭 7. Casi Speciali e Valori Particolari

🔴 Zero

+0: 0 00000000 00000000000000000000000
-0: 1 00000000 00000000000000000000000

Nota: +0 e -0 sono considerati uguali nelle operazioni!

♾️ Infinito

💡 Quando si ottiene infinito?

Divisione per zero: 1.0 / 0.0 = +∞
Overflow: numero troppo grande
Operazioni: ∞ + 5 = ∞, ∞ × 2 = ∞

+∞: 0 11111111 00000000000000000000000
-∞: 1 11111111 00000000000000000000000

🚫 NaN (Not a Number)

⚠️ Operazioni che producono NaN

0.0 / 0.0
∞ - ∞
∞ / ∞
√(-1)
log(-5)

NaN: s 11111111 qualsiasi valore ≠ 0

Proprietà di NaN:
• NaN ≠ NaN  (anche con se stesso!)
• Qualsiasi operazione con NaN produce NaN
• NaN si propaga attraverso i calcoli

🔬 Numeri Denormalizzati (Subnormal)

I numeri denormalizzati permettono di rappresentare valori molto vicini allo zero, riempiendo il "gap" tra 0 e il più piccolo numero normalizzato.

💡 Numeri denormalizzati

Esponente = 00000000
Mantissa ≠ 00000000...
Il "1." implicito diventa "0."
Formula: (-1)ˢ × 0.mantissa × 2⁻¹²⁶

🔄 8. Conversioni Pratiche

📥 Da decimale a IEEE 754

Algoritmo completo

Gestisci il segno: Se negativo, s=1 e lavora col valore assoluto
Converti in binario: Sia parte intera che frazionaria
Normalizza: Sposta la virgola dopo il primo 1 e conta l'esponente
Calcola esponente con bias: E_memorizzato = E_reale + 127 (float)
Estrai mantissa: I bit dopo il punto, senza il "1." iniziale
Combina: [S][Esponente][Mantissa]

📤 Da IEEE 754 a decimale

Algoritmo completo

Estrai i bit: Separa segno, esponente e mantissa
Verifica casi speciali: Zero, infinito, NaN
Calcola esponente reale: E_reale = E_memorizzato - 127
Ricostruisci mantissa: 1.mantissa in decimale
Applica la formula: (-1)ˢ × mantissa × 2^E_reale

Esempio: Decodificare 0 10000010 10001100000000000000000

Passo 1: Estrai i componenti
   Segno: 0 (positivo)
   Esponente: 10000010 = 130₁₀
   Mantissa: 10001100000000000000000

Passo 2: Calcola esponente reale
   E_reale = 130 - 127 = 3

Passo 3: Ricostruisci la mantissa
   1.10001100000000000000000
   = 1 + 1×2⁻¹ + 0×2⁻² + 0×2⁻³ + 0×2⁻⁴ + 1×2⁻⁵ + 1×2⁻⁶
   = 1 + 0.5 + 0.03125 + 0.015625
   = 1.546875

Passo 4: Applica la formula
   Valore = (+1) × 1.546875 × 2³
         = 1.546875 × 8
         = 12.375

Risultato: 12.375₁₀

🧮 9. Calcolatori Interattivi

🔢 Convertitore Complemento a 2

Complemento a 2

Numero decimale:

Numero di bit:

📍 Convertitore Virgola Fissa

Fixed-Point Converter

Numero decimale:

Formato:

🌊 Convertitore IEEE 754

IEEE 754 Floating-Point

Numero decimale:

Precisione:

🔍 Decodificatore IEEE 754

Decodifica binario IEEE 754

Rappresentazione binaria (32 bit):

📝 10. Esercizi Interattivi

🎲 Generatore di Esercizi

Esercizi Complemento a 2

Esercizi Virgola Fissa

Esercizi IEEE 754

⚠️ 11. Errori Comuni e Insidie

❌ Errore 1: Confrontare float con ==

// SBAGLIATO
if (0.1 + 0.2 == 0.3) {  // Può essere falso!
    // codice
}

// CORRETTO
const epsilon = 1e-10;
if (Math.abs((0.1 + 0.2) - 0.3) < epsilon) {
    // codice
}

Motivo: Gli errori di arrotondamento rendono i confronti diretti inaffidabili.

❌ Errore 2: Dimenticare il bias dell'esponente

Problema: Usare l'esponente binario direttamente senza sottrarre il bias
Soluzione: Float: E_reale = E_binario - 127, Double: E_reale = E_binario - 1023

❌ Errore 3: Dimenticare il bit implicito

Problema: Trattare la mantissa come 0.xxx invece di 1.xxx
Soluzione: La mantissa normalizzata è sempre 1.xxx (il "1." è implicito!)

❌ Errore 4: Overflow/Underflow non gestito

float x = 3.4e38;
float y = x * 10;  // Overflow → +∞

float z = 1.0e-38;
float w = z / 1e10;  // Underflow → 0 (o denormalizzato)

Soluzione: Verifica sempre i risultati di calcoli con numeri estremi.

❌ Errore 5: Accumulo di errori

// SBAGLIATO (errori si accumulano)
float sum = 0.0;
for (int i = 0; i < 10000000; i++) {
    sum += 0.1;
}
// sum ≠ 1000000.0 esattamente!

// MIGLIORE
float sum = 0.1 * 10000000;  // Meno passaggi = meno errori

❌ Errore 6: Perdita di precisione nelle sottrazioni

float a = 1.0000001;
float b = 1.0;
float diff = a - b;  // Catastrofica cancellazione!

// La precisione relativa si perde quando 
// si sottraggono numeri molto simili

Soluzione: Riorganizza i calcoli per evitare sottrazioni tra numeri simili.

🎯 12. Trucchi e Ottimizzazioni

✅ Trucco 1: Test rapido del segno

// In C/C++, per vedere se un float è negativo:
int bits = *(int*)&myFloat;
bool isNegative = (bits < 0);  // MSB = 1

// Funziona perché il bit di segno è il MSB

✅ Trucco 2: Confronto veloce di float

// Confronta float come interi (funziona per positivi!)
int a_bits = *(int*)&float_a;
int b_bits = *(int*)&float_b;

// Per IEEE 754, l'ordine binario = ordine numerico
if (a_bits < b_bits) {
    // float_a < float_b
}

✅ Trucco 3: Inversione rapida della radice quadrata (Fast Inverse Square Root)

// Famoso trucco del gioco Quake III
float InvSqrt(float x) {
    float xhalf = 0.5f * x;
    int i = *(int*)&x;
    i = 0x5f3759df - (i >> 1);  // Magia!
    x = *(float*)&i;
    x = x * (1.5f - xhalf * x * x);  // Newton iteration
    return x;
}

// Calcola 1/√x molto più velocemente dell'hardware!

✅ Trucco 4: Verifica se float è potenza di 2

bool isPowerOf2(float x) {
    // Se è potenza di 2, la mantissa è tutta 0
    int bits = *(int*)&x;
    int mantissa = bits & 0x7FFFFF;
    return (mantissa == 0 && x > 0);
}

✅ Trucco 5: Estrazione dell'esponente

int getExponent(float x) {
    int bits = *(int*)&x;
    int exp = (bits >> 23) & 0xFF;  // Estrai 8 bit
    return exp - 127;  // Rimuovi bias
}

// Utile per calcoli veloci di log₂(x)

✅ 13. Checklist di Autovalutazione

📋 Numeri Negativi

☐ Conosco le differenze tra segno-modulo, complemento a 1 e complemento a 2
☐ So calcolare il complemento a 2 di un numero
☐ Capisco perché il complemento a 2 è lo standard
☐ So qual è il range di valori per N bit in complemento a 2
☐ Riconosco un numero negativo guardando il MSB

📋 Virgola Fissa

☐ Capisco il formato Qm.n
☐ So convertire numeri decimali in virgola fissa
☐ So convertire la parte frazionaria con moltiplicazioni successive
☐ Conosco i limiti di range e precisione

📋 IEEE 754 Single Precision

☐ Conosco la struttura: 1 bit segno + 8 bit esponente + 23 bit mantissa
☐ Capisco il concetto di bias (127 per float)
☐ So cos'è il bit implicito nella mantissa
☐ So normalizzare un numero binario (1.xxx × 2ⁿ)
☐ So convertire da decimale a IEEE 754
☐ So decodificare un numero IEEE 754 in decimale
☐ Riconosco i valori speciali (±0, ±∞, NaN)

📋 IEEE 754 Double Precision

☐ Conosco le differenze tra float e double
☐ So che il bias è 1023 per double
☐ Capisco il trade-off tra precisione e range

📋 Concetti Avanzati

☐ Capisco gli errori di arrotondamento
☐ So perché non si devono confrontare float con ==
☐ Conosco il concetto di epsilon macchina
☐ Comprendo overflow e underflow
☐ So cosa sono i numeri denormalizzati

🎓 Conclusione

Complimenti! Hai completato questa guida completa sulla rappresentazione di numeri negativi e reali in binario!

Ora comprendi come i computer rappresentano realmente tutti i tipi di numeri, dai negativi ai decimali. Questa conoscenza è fondamentale per capire i limiti e le caratteristiche dei calcoli al computer. 💻

Continua a esercitarti con i calcolatori interattivi e gli esercizi randomici! 🎯

"In informatica, 2.0 + 2.0 = 4.0, ma 0.1 + 0.2 potrebbe non essere esattamente 0.3!" 😄